함수와 메서드 - def, return, 변수, 인자, dir, help, 내포함수

[참조]

• 공학자를 위한 Python, 조정래, 2022: 2.3 함수와 클래스
  https://wikidocs.net/14596
• Dookie Kim, Python: From Beginning to Application, 2022: Chapter 1. Introduction [PDF]

📖 목차

(1) 내장 함수 (Built-in Function)

파이썬에는 기본적으로 포함되어 바로 사용할 수 있는 다양한 내장 함수가 존재한다. 이러한 함수들은 수치 계산, 자료형 변환, 자료 구조 탐색 및 제어 등에 널리 사용되며, 프로그램의 간결성과 효율성을 높여준다.

아래는 자주 사용되는 일부 내장 함수와 그 사용 예이다.

abs(x) all(iterable) any(iterable) ascii(object)
bin(x) bool(x) bytearray(), bytes()
callable(x) chr(i) classmethod() compile() complex()
delattr() dict() 📌 dir() divmod(a, b)
enumerate(iterable) eval(expression) exec()
filter(function, iterable) float(x) 📌 format() 📌 f-string (formatted string literal)
globals()
hasattr(object, name) hash(object) 📌 help() hex(x)
id(object) input(prompt) int(x) isinstance(object, class) issubclass(sub, super) iter(object)
lambda len(iterable) list() locals()
map(function, iterable) max(), min()
next(iterator)
object() oct(x) open(file, mode) ord(char)
pow(a, b) print() property()
📌 range() repr(obj) reversed(seq) round(x)
set() setattr(obj, name, value) slice(start, stop, step) sorted(iterable) staticmethod() str(x) sum(iterable) super()
tuple() type(obj)
vars()
zip()
__import__()

• abs(x)
  숫자 x의 절댓값을 반환
  Ex)
  abs(3+4j)
• all(iterable)
  반복 가능한 자료의 모든 요소가 True이면 True를 반환
  Ex)
  all([1, 2, 3]) → True
all([1, [], 3]) → False
• any(iterable)
  하나라도 True인 값이 있으면 True를 반환
  Ex)
  any([1, 2, 3]) → True
any([1, [], 3]) → True
• ascii(object)
  비 ASCII 문자를 이스케이프한 문자열을 반환
• bin(x)
  정수 x를 이진수 문자열로 변환
  Ex)
  bin(2) → '0b10'
• bool(x)
  논리값 True 또는 False 반환
  Ex)
  bool(a == 3)
• bytearray(), bytes()
  바이트형 자료 생성
• callable(x)
  객체 x가 호출 가능한지 여부 반환
  Ex)
  callable(a)
• chr(i)
  유니코드 정수 값을 문자로 반환
  Ex)
  chr(97) → 'a'
ord('a') → 97
• classmethod()
• compile()
• complex()
• delattr()
• dict()
• 📌 dir()

  dir() 함수는 객체(또는 모듈)의 멤버(함수, 상수 등)의 이름을 리스트로 반환한다. 이를 통해 해당 객체나 모듈에 어떤 기능이 포함되어 있는지를 확인할 수 있다.

  dir() 함수는 사용자 정의 객체나 클래스에 대해서도 동일하게 사용할 수 있으며, 해당 객체가 어떤 속성과 메서드를 가지고 있는지 탐색하는 데 유용하다.

  Ex) math 모듈에 포함된 함수 목록 확인

  
  >>> import math
  >>> dir(math)
  ['__doc__', '__loader__', '__name__', '__package__', '__spec__',
   'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh',
   'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist',
   'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor',
   'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf',
   'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp',
   'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm',
   'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh',
   'sqrt', 'tan', 'tanh', 'tau', 'trunc']
  

  Ex) 클래스가 list인
  객체 my_list에 포함된 매서드(클래스에 포함된 함수)의 목록 확인

  
  >>> my_list = [1, 2, 3]
  >>> dir(my_list)
  ['__add__', '__class__', '__contains__', '__delattr__', 
   '__delitem__', '__delslice__', '__eq__', '__format__', 
   '__ge__', '__getitem__', '__getslice__', '__gt__', '__hash__', 
   '__iadd__', '__imul__', '__init__', '__iter__', '__le__', 
   '__len__', '__lt__', '__mul__', '__ne__', '__repr__', 
   '__reversed__', '__rmul__', '__setattr__', '__setitem__', 
   '__setslice__', '__sizeof__', '__str__', 'append', 'clear', 
   'copy', 'count', 'extend', 'index', 'insert', 'pop', 
   'remove', 'reverse', 'sort']
  

• divmod(a, b)
  a를 b로 나눈 몫과 나머지를 튜플로 반환
  Ex)
  divmod(5, 3) → (1, 2)
• enumerate(iterable)
  반복 가능한 객체를 인덱스와 함께 튜플 형태로 반환
  Ex)
  list(enumerate(['Spring', 'Summer', 'Fall', 'Winter']))
  → [(0, 'Spring'), (1, 'Summer'), ...]
• eval(expression)
  문자열로 된 표현식을 실행하고 그 결과를 반환
  Ex)
  x = 1; eval('x + 1') → 2
• exec()
  문자열로 된 파이썬 코드를 실행 (결과는 반환하지 않음)
• filter(function, iterable)
  조건에 부합하는 요소만 필터링하여 남김
  Ex)
  list(filter(lambda x: x < 0, [-5, -3, 0, 3, 5]))
  →[-5, -3]
• float(x)
  문자열이나 정수를 실수형으로 변환
  Ex)
  float(input("x = ?"))
• 📌 format()

  format() 함수는 문자열 내부에 특정 값을 삽입하거나 서식을 지정하기 위해 사용된다. 문자열 내의 중괄호 {}는 플레이스홀더(placeholder) 역할을 하며, 여기에 대응하는 값들을 format() 함수 인자로 전달하여 대입한다.

  Ex) 인덱스 기반 format

  
  >>> '{0}, {1}, {2}'.format('a', 'b', 'c')
  'a, b, c'
  

  Ex) 변수 기반 format

  
  >>> height = 175  # 단위: cm
  >>> gender = "남자"
  >>> weight = 67.38
  >>> print("키 {0}cm {1}의 표준체중은 {2}kg 입니다.".format(height, gender, weight))
  키 175cm 남자의 표준체중은 67.38kg 입니다.
  

• 📌 f-string (formatted string literal)

  파이썬 3.6 이상에서는 문자열 앞에 접두사 f를 붙여, 중괄호 {} 안에 변수나 표현식을 직접 삽입할 수 있는 f-string 문법을 사용할 수 있다. 이 방식은 format() 함수보다 더 간결하고 가독성이 뛰어나다.

  Ex)

  
  >>> print(f"키 {height}cm {gender}의 표준체중은 {weight}kg 입니다.")
  키 175cm 남자의 표준체중은 67.38kg 입니다.
  

문자열 서식 지정 방법에는 1) f-string, 2) format() 함수, 3) 문자열 연결, 4) % 포맷팅 방식이 있으며, 상황에 따라 적절히 선택하여 사용할 수 있다.

[Note] 문자열 포맷팅 방식 비교

문자열에 변수를 삽입하여 표현하는 방법은 여러 가지가 있으며, 다음은 대표적인 세 가지 방식이다.

가. f-string 방식 (파이썬 3.6 이상 권장)

print(f"키 {height}cm {gender}의 표준체중은 {weight}kg 입니다.")

나. 문자열 연결 방식

print("키 " + str(height) + "cm " + gender + "의 표준체중은 " + str(weight) + "kg 입니다.")

다. % 포맷팅 방식

print("키 %scm %s의 표준체중은 %skg 입니다." % (height, gender, weight))

이 중에서 f-string 방식은 가독성과 실행 성능 면에서 가장 효율적이므로, 최신 파이썬 환경에서는 이를 사용하는 것이 일반적으로 권장된다.

• frozenset()
  변경 불가능한 집합(immutable set)을 생성
• getattr(object, name)
  객체에서 특정 속성의 값을 반환
• globals()
  현재 전역 심볼 테이블을 딕셔너리 형태로 반환
• hasattr(object, name)
  객체에 특정 속성이 존재하는지 여부를 True/False로 반환
• hash(object)
  객체의 해시 값을 반환 (딕셔너리의 키 등에 사용됨)
• 📌 help()

  help() 함수는 파이썬 내장 함수 또는 모듈, 클래스, 객체 등에 대한 설명(도움말)을 출력하는 데 사용된다. 특정 함수의 용도, 매개변수, 반환값 등에 대한 정보를 확인할 수 있으며, 학습 또는 개발 중 유용하게 활용된다.

  Ex)

  
  >>> import math
  >>> help(math.sin)
  
  Help on built-in function sin in module math:
  
  sin(x, /)
      Return the sine of x (measured in radians)
  

  help()는 터미널이나 인터프리터 환경에서 직접 실행하는 것이 일반적이며, 객체에 대한 빠른 설명을 확인할 수 있다.

• hex(x)
  정수 x를 16진수 문자열로 변환
• id(object)
  객체의 고유 식별자(메모리 주소)를 반환
  Ex)
  a = 3; b = a; id(a) == id(b)
• input(prompt)
  사용자 입력을 문자열로 받아 반환
  Ex)
  s = input("--> ")
• int(x)
  숫자 또는 문자열을 정수로 변환
  Ex)
  int("1") → 1
• isinstance(object, class)
  객체가 지정한 클래스의 인스턴스인지 여부 확인
  Ex)
  isinstance(a, Person)
• issubclass(sub, super)
  클래스가 특정 클래스를 상속받았는지 여부 판단
• iter(object)
  반복 가능한 객체의 이터레이터(iterator) 객체 반환
  Ex)
  list(iter("formidable")) → ['f', 'o', 'r', ...]
• lambda
  이름이 없는 익명 함수(함수 축약형)를 정의할 때 사용
  주로 한 줄로 표현 가능한 간단한 함수에 사용됨
  Ex)
  sum = lambda a, b: a + b
• len(iterable)
  문자열, 리스트, 튜플 등 반복 가능한 객체의 길이를 반환
  Ex)
  len([1, 3, 'a']) → 3
• list()
  문자열, 튜플, 집합 등 반복 가능한 객체를 리스트로 변환
  Ex)
  list('python') → ['p', 'y', 't', 'h', 'o', 'n']
• locals()
  현재 지역 스코프(Local scope)의 변수 정보를 딕셔너리 형태로 반환
• map(function, iterable)
  반복 가능한(iterable) 객체의 각 요소에 함수(function)를 적용하여 생성된 객체(iterator)를 반환
  Ex)
  list(map(lambda x: x**2, [1, 3, 5])) → [1, 9, 25]
• max(), min()
  반복 가능한 객체에서 최댓값 또는 최솟값 반환
  Ex)
  max([1, 3, 5]) → 5
min([1, 3, 5]) → 1
• next(iterator)
  이터레이터 객체의 다음 항목을 반환
  Ex)
  

  
  x = iter([1, 3, 5])
  next(x)  # 1
  next(x)  # 3
  

• object()
  모든 클래스의 기본 객체 생성
• oct(x)
  정수 x를 8진수 문자열로 변환
• open(file, mode)
  파일을 열거나 새로 생성
  Ex)
  f = open("file.txt", "w"); f.write(data)
• ord(char)
  문자의 유니코드 정수값 반환
  Ex)
  ord('a') → 97
chr(97) → 'a'
• pow(a, b)
  a의 b제곱을 반환
  Ex)
  pow(2, 3) → 8
• print()
  출력 함수
  Ex)
  print("Hello")
• property()
  클래스의 속성 접근자 정의에 사용
• 📌 range()

  range() 함수는 숫자의 시퀀스를 생성할 때 사용되며, 반복문과 함께 자주 사용된다. 생성된 객체는 list()로 변환하여 확인할 수 있다.

  (형식)

  
  range(stop)
  range(start, stop)
  range(start, stop, step)
  

  Ex)

  
  # 0부터 4까지 출력
  for i in range(5):
      print(i)
  
  # 1부터 9까지 홀수 출력
  for i in range(1, 10, 2):
      print(i)
  
  # 리스트로 변환
  nums = list(range(3, 8))
  print(nums)  # [3, 4, 5, 6, 7]
  

  range(n)은 0부터 n-1까지 생성한다.

  range(start, stop)은 start부터 stop-1까지 생성한다.

  range(start, stop, step)은 step만큼 증가시키며 생성한다.

• repr(obj)
  객체를 표현 가능한 문자열로 반환
• reversed(seq)
  순서를 반대로 뒤집은 이터레이터 반환
• round(x)
  숫자 x를 반올림
  Ex)
  round(3.5) → 4
• set()
  집합 자료형으로 변환
  Ex)
  set([1, 2, 3]) → {1, 2, 3}
• setattr(obj, name, value)
  객체의 속성을 동적으로 설정
• slice(start, stop, step)
  슬라이싱 객체를 생성
• sorted(iterable)
  정렬된 리스트 반환
  Ex)
  sorted([1, 5, 3, 5]) → [1, 3, 5, 5]
• staticmethod()
  클래스 내 정적 메서드(static method)를 정의
• str(x)
  숫자나 객체를 문자열로 변환
  Ex)
  str(3) → '3'
• sum(iterable)
  요소들의 합을 반환
  Ex)
  sum([1, 2, 3]) → 6
• super()
  부모 클래스의 메서드를 호출할 때 사용
• tuple()
  튜플 자료형으로 변환
  Ex)
  tuple([1, 2, 3])
• type(obj)
  객체의 자료형 반환
  Ex)
  type(3) → <class 'int'>
• vars()
  객체의 속성 정보를 딕셔너리로 반환
• zip()
  여러 시퀀스를 병렬로 묶어 튜플로 구성된 이터레이터 반환
  Ex)
  list(zip([1,2,3], [4,5,6]))
  →[(1, 4), (2, 5), (3, 6)]
• __import__()
import 문과 동일한 기능을 수행하는 내장 함수 (고급 사용용도)

(2) 함수와 메서드의 정의: def

1) 함수(Function)와 메서드(Method)의 차이
2) 함수 정의의 기본 구조

1) 함수(Function)와 메서드(Method)의 차이

프로그래밍 언어에서 함수와 메서드는 모두 특정 작업을 수행하기 위한 코드 블록을 의미하지만, 사용되는 문맥과 호출 방식에서 차이가 존재한다.

구분	함수 (Function)	메서드 (Method)
정의 위치	클래스 외부 또는 독립적으로 정의됨	클래스 내부에 정의되어 객체를 통해 호출됨
호출 방법	함수이름(인자)	객체.메서드이름(인자)
self 사용 여부	사용하지 않음	첫 번째 인자로 self를 사용함
Ex) 코드	def add(a, b): return a + b	class Calc:  def add(self, b):   return self.a + b
대표 예	len([1, 2, 3]) (내장 함수)	"text".upper() (문자열 메서드)

즉, 함수는 독립적으로 사용할 수 있는 반면, 메서드는 객체와 함께 사용하는 객체 지향적 함수라고 할 수 있다.

파이썬에서 함수는 def 키워드를 사용하여 정의한다. 함수는 특정 작업을 수행하는 명령문 집합으로, 코드의 재사용성과 구조화를 돕는다.

2) 함수 정의의 기본 구조

def 함수이름(매개변수1, 매개변수2, ...):
    실행할 코드
    return 반환값

Ex) 두 수를 더하는 함수

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 출력: 8

Ex) 반환값 없이 단순 출력

def greet(name):
    print(f"{name}님, 반갑습니다!")

greet("민수")  # 출력: 민수님, 반갑습니다!

Ex) 인자가 없는 함수

def print_logo():
    print("=== My Program ===")

print_logo()

(3) 매개변수와 인자

함수 정의와 호출 시 사용되는 값과 변수는 다음과 같이 구분된다.

• 매개변수(Parameter): 함수가 정의될 때 입력을 받기 위해 선언된 변수
• 인자(Argument): 함수가 호출될 때 매개변수에 전달되는 실제 값

구분	역할	예시 코드	예시 이름
파라미터	함수 정의에 사용됨	def f(x):	x (파라미터)
인자	함수 호출에 전달됨	f(10)	10 (인자)

Ex)

def add_text(t1, t2="파이썬"):
    print(t1 + " : " + t2)

add_text("hello", "python")  # t1="hello", t2="python"
add_text("hi")               # t1="hi", t2="파이썬" (기본값 사용)

이 예시에서 t1, t2는 매개변수이며, 함수 호출 시 전달된 "hello", "python"은 인자이다. t2는 기본값을 가지므로 두 번째 인자를 생략할 수 있다.

요약

• 매개변수는 함수 정의부에서 선언
• 인자는 함수 호출부에서 전달
• 기본값이 있는 매개변수는 선택적으로 전달 가능

(4) 함수값 return

함수는 실행 결과를 반환하기 위해 return 문을 사용한다. 반환값은 하나일 수도 있고, 여러 개일 경우 튜플 형태로 반환된다. 함수는 return 문을 만나면 즉시 실행을 종료하고, 해당 값을 호출한 위치로 전달한다.

def add(a, b):
    return a + b

result = add(3, 5)  # result는 8이 된다.

여러 개의 값을 반환하고자 할 경우, 쉼표로 구분하여 작성하면 튜플로 반환된다.

def calculate(a, b):
    sum_ = a + b
    diff = a - b
    return sum_, diff

x, y = calculate(10, 3)
print(x)  # 13
print(y)  # 7

(5) mutable(변경 가능) vs immutable(변경 불가능) 인자

파이썬에서는 객체의 변경 가능 여부에 따라 자료형이 mutable과 immutable로 구분된다.

• mutable: 리스트(list), 딕셔너리(dict), 집합(set) 등
• immutable: 정수(int), 실수(float), 문자열(str), 튜플(tuple) 등

함수 호출 시 mutable 객체를 인자로 전달하면, 함수 내부에서 해당 객체를 변경할 수 있으며, 그 변경 사항은 호출한 쪽에도 영향을 미친다.

def modify_list(lst):
    lst.append(100)

numbers = [1, 2, 3]
modify_list(numbers)
print(numbers)  # [1, 2, 3, 100]

반면, immutable 객체는 함수 내에서 값을 변경하더라도 원본에는 영향을 주지 않는다.

def modify_value(x):
    x += 10

a = 5
modify_value(a)
print(a)  # 5 (변경되지 않음)

(6) 기본값(default) 및 선택적(optional) 인자 지정

함수를 정의할 때 인자에 기본값을 지정하면, 호출 시 해당 인자를 생략할 수 있다. 이러한 인자는 선택적 인자(optional parameter)라고도 하며, 함수의 유연성을 높여준다.

def greet(name, message="안녕하세요"):
    print(f"{message}, {name}님!")

greet("민수")                # 안녕하세요, 민수님!
greet("지영", "환영합니다")  # 환영합니다, 지영님!

기본값이 지정된 인자는 반드시 기본값이 없는 인자 뒤에 와야 한다.

# 올바른 예
def func(a, b=0): pass

# 잘못된 예 (SyntaxError 발생)
def func(a=0, b): pass

복잡한 수식에서 optional 인자는 함수 내부에서 조건문을 사용해 분기처리를 할 수 있다.

def compute(value, method='exact'):
    if method == 'exact':
        return value ** 2
    else:
        return round(value ** 2, 1)

(7) 인자의 개수가 정해지지 않을 때 *args와 **kwargs

함수를 정의할 때 전달되는 인자의 개수가 고정되어 있지 않은 경우, 파이썬에서는 *args와 **kwargs를 사용하여 가변적인 개수의 인자를 받을 수 있다.

1) *args – 위치 인자(Non-keyword arguments)
2) **kwargs – 키워드 인자(Keyword arguments)
3) *args와 **kwargs의 혼용
요약

1) *args – 위치 인자(Non-keyword arguments)

*args는 함수에 전달되는 인자를 **튜플(tuple)** 형태로 받아들이며, 개수에 제한이 없다. 함수 내부에서는 일반적인 반복문을 통해 개별 인자에 접근할 수 있다.

def add(*args):
    result = 0
    for num in args:
        result += num
    return result

add(1, 2, 3)  # 결과: 6

2) **kwargs – 키워드 인자(Keyword arguments)

**kwargs는 키워드 형태로 전달되는 인자들을 **딕셔너리(dictionary)** 형태로 받아들인다. 함수 내부에서는 키(key)와 값(value) 쌍으로 인자를 처리할 수 있다.

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

print_info(name="Alice", age=30, job="Engineer")

출력

name = Alice
age = 30
job = Engineer

3) *args와 **kwargs의 혼용

함수 정의 시 *args와 **kwargs는 함께 사용할 수 있으며, 반드시 *args가 먼저, **kwargs가 뒤에 와야 한다.

def mixed_example(fixed, *args, **kwargs):
    print(f"기본 인자: {fixed}")
    print(f"가변 인자: {args}")
    print(f"키워드 인자: {kwargs}")

mixed_example("기본값", 1, 2, 3, lang="Python", level="Intermediate")

출력

기본 인자: 기본값
가변 인자: (1, 2, 3)
키워드 인자: {'lang': 'Python', 'level': 'Intermediate'}

요약

• *args는 위치 기반 인자를 튜플로 받음
• **kwargs는 키워드 기반 인자를 딕셔너리로 받음
• 두 개를 함께 사용할 경우, 순서에 유의할 것: 일반 인자 → *args → **kwargs

(8) 함수 내 함수 (Nested Function)

파이썬에서는 하나의 함수 내부에 또 다른 함수를 정의할 수 있다. 이를 중첩 함수(nested function) 또는 내부 함수(inner function)라고 하며, 외부 함수의 일부 로직을 내부적으로 캡슐화하거나, 클로저(closure) 구조를 구현할 때 자주 사용된다.

내부 함수는 자신을 포함하고 있는 외부 함수의 변수에 접근할 수 있으며, 외부에서는 호출할 수 없다. 이러한 특징을 통해 **함수 내의 일시적인 계산**, **정보 은닉**, **코드 구조화** 등의 효과를 얻을 수 있다.

Ex)

def outer_function():
    outer_list = [1, 2]
    
    def inner_function():
        outer_list.append(3)
    
    inner_function()
    print(outer_list)

outer_function()

결과

[1, 2, 3]

해설

• inner_function()은 outer_function() 내부에 정의되어, 외부 함수가 실행될 때만 호출 가능하다.
• 내부 함수는 외부 함수의 변수 outer_list에 접근할 수 있으며, 그 값을 변경할 수도 있다.
• 외부 함수의 실행이 종료되면 내부 함수는 소멸한다.

이와 같이 중첩 함수는 임시적인 처리 또는 특정 조건 하에서만 유효한 로직을 정의할 때 유용하게 사용된다. 또한 데코레이터(decorator)와 같은 고급 기능의 구현에서도 핵심적인 역할을 수행한다.

(9) 사용자 정의 함수로 저장한 파일을 import로 불러오기

사용자가 직접 정의한 함수를 하나의 파이썬 파일(.py)로 저장해 두고, 이후 다른 파이썬 파일에서 import 문을 통해 해당 함수를 불러올 수 있다. 이러한 방식은 코드의 재사용성과 모듈화를 가능하게 하며, 협업 및 대규모 프로젝트 구성에도 효과적이다.

1) 함수 정의 파일 예시
2) import를 통한 함수 불러오기
3) 모듈의 위치
4) 별칭(alias) 사용

1) 함수 정의 파일 예시

# 파일명: my_module.py

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

2) import를 통한 함수 불러오기

다른 파이썬 파일 또는 인터프리터 환경에서 import 또는 from ... import ... 구문을 통해 함수를 사용할 수 있다.

# 전체 모듈 불러오기
import my_module

result = my_module.add(3, 4)

# 특정 함수만 불러오기
from my_module import multiply

result = multiply(5, 2)

3) 모듈의 위치

모듈 파일은 같은 디렉토리에 있거나, PYTHONPATH 환경 변수 또는 sys.path에 등록된 경로 내에 존재해야 import가 가능하다.

import sys
print(sys.path)  # 모듈 검색 경로 확인

4) 별칭(alias) 사용

import my_module as mm

print(mm.add(1, 2))  # 별칭으로 함수 호출 가능

이와 같이 사용자 정의 함수 파일을 외부에서 모듈로 불러와 사용할 수 있으며, 복잡한 코드 구조를 기능별로 나누어 관리할 수 있다.

(10) 내포함수(內包함수; 內for함수;comprehension function)

파이썬의 내포(comprehension) 함수는 컬렉션 자료형(리스트, 튜플, 집합, 딕셔너리 등)을 보다 간결하고 직관적인 문법으로 생성할 수 있도록 하는 표현식이다. 기존의 반복문과 조건문을 한 줄로 표현함으로써 코드의 가독성을 높이며, 간단한 자료 구조를 선언할 때 유용하게 활용된다.

내포 함수를 활용하면 반복문과 조건문을 간결하게 표현할 수 있으며, 동일한 결과를 더 적은 코드로 구현할 수 있다. 특히 리스트나 딕셔너리 생성 시 자주 사용된다.

내포 함수는 주로 리스트 내포(list comprehension), 딕셔너리 내포(dictionary comprehension), 집합 내포(set comprehension), 제너레이터 표현식(generator expression)으로 구분된다.

1) 리스트 내포 (List Comprehension)
2) 딕셔너리 내포 (Dictionary Comprehension)
3) 집합 내포 (Set Comprehension)
4) 제너레이터 표현식 (Generator Expression)

1) 리스트 내포 (List Comprehension)

# 기존 방식
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i)

# 표현식
[expression for item in iterable if condition]

# 리스트 내포 방식
result = [i for i in range(10) if i % 2 == 0]

2) 딕셔너리 내포 (Dictionary Comprehension)

# 기존 방식
squares = {}
for i in range(5):
    if i % 2 == 1:
        squares[i] = i * i

# 표현식
{key_expr: value_expr for item in iterable if condition}

# 딕셔너리 내포 방식
squares = {i: i * i for i in range(5) if i % 2 == 1}

3) 집합 내포 (Set Comprehension)

# 기존 방식
unique_lengths = set()
words = ["apple", "banana", "cherry"]
for word in words:
    if len(word) > 5:
        unique_lengths.add(len(word))

# 표현식
{expression for item in iterable if condition}

# 집합 내포 방식
unique_lengths = {len(word) for word in ["apple", "banana", "cherry"] if len(word) > 5}

4) 제너레이터 표현식 (Generator Expression)

튜플 내포는 명시적으로 존재하지 않지만, 제너레이터 표현식을 사용하여 유사한 동작을 수행할 수 있다.

# 기존 방식
def square_gen():
    for i in range(5):
        if i % 2 == 0:
            yield i * i

gen = square_gen()

# 표현식
(expression for item in iterable if condition)

# 제너레이터 표현식
gen = (i * i for i in range(5) if i % 2 == 0)